Hur man effektivt rapporterar skjutfönster med en fast längd på några sekunder

Jag tror att du menade steg baserat på "För varje fönster med längd 2 sekunder som börjar vid en andra gräns" och inte överlappar varandra. För två sekunders intervall är det samma, men eftersom du vill variera längden, skulle en överlappning på en sekund vara 0-3, 2-5, 4-7, men steg skulle innebära 0-3, 1-4, 2- 5. Det var dock intressant att räkna ut lösningar för båda för en säkerhets skull.
Förutsatt att L är sorterat och alla element är positiva och att de andra intervallen börjar med heltal kan vi använda den här metoden:
importera matematik
från samlingar importerar standarddikt
L = [0.10218048, 1.20851996, 1.46800021, 1.73429061, 2.71525848,
3.14781922, 3.63637958, 5.11147358, 5.97497864, 6.35469013,
6,80623747, 6,99571917, 7,65215123, 7,86108352, 8,52988247,
8.83068894, 10.07690977, 11.53867284, 12.01214112, 12.13307653]
my_ranges = defaultdict (lista)
intervall_bredd = 2
för x i L:
upper_bound = math.ceil (x)
lower_bound = upper_bound - interval_width
lower_bound = max (0, lower_bound)
för y i intervallet (nedre, övre, övre):
my_ranges [y] .append (x)
för en i sorterad (min_områden):
skriv ut (min_områden [a])
Jag vet inte om du vill se om det finns några tomma intervall. Men defaultdict skriver ut tomma intervall om du vill också. Använd den här raden istället för "för en in sorterad":
för en inom räckvidd (min (min_ranges), max (min_ranges) + 1):
Om du ville ha intervallen 0-3, 2-5, 4-7 fungerar det här:
importera matematik
från samlingar importerar standarddikt
L = [0.10218048, 1.20851996, 1.46800021, 1.73429061, 2.71525848,
3.14781922, 3.63637958, 5.11147358, 5.97497864, 6.35469013,
6,80623747, 6,99571917, 7,65215123, 7,86108352, 8,52988247,
8.83068894, 10.07690977, 11.53867284, 12.01214112, 12.13307653]
intervall_bredd = 2
my_ranges_2 = defaultdict (lista)
för x i L:
definitivt_in = (x // (intervallbredd - 1)) * (intervallbredd - 1) # lägsta multipel av intervallbredd under x kommer alltid att vara i
#print ("Lägga till", x, "till", definitivt_in)
my_ranges_2 [definitivt_in] .append (x)
om x  = 0: # till exempel, om x är 2,3 och vi har 0,3 2,5 etc. ... måste vi fånga detta dubbla fall. Jag antar att fönsterlängderna är heltal, och om inte, har vi mycket mer att göra, eftersom antalet kan gå i mer än en grupp. Kanske kan vi ha en stundslinga, öka med (intervallbredd - 1)
#print ("++ Lägga till", x, "till", definitivt_in - intervallbredd + 1)
my_ranges_2 [definitivt_in - intervallbredd + 1] .append (x)
för en i sorterad (my_ranges_2):
skriv ut (a, my_ranges_2 [a])
# utskrift (my_ranges_2 [a])
Jag misstänker att det finns några detaljer jag har glömt, men förhoppningsvis kan du vrida intervallbredd som behov för att se till att min kod gör vad du hoppades på och låta mig veta vad du behöver.
|
En möjlig lösning som jag kan föreslå är "effektiv" på sätt och vis att den endast itererar en gång genom ingångsdata och saknar beroenden. Kostnaden är naturligtvis att den är skriven i ren python (det kan finnas mer optimerad kod) och att den introducerar fler spårningsvariabler för att förhindra upprepning (och därmed är mindre pythonic).
def sliding_window (data, varaktighet, start = 0, överlappning = 1):
resultat = []
data_idx = 0
resultat_idx = 0
övre = start + varaktighet
lägre = start
next_lower = övre - överlappning
# inre hjälpare för att lägga till tomma innerlistor upp till vår infoga punkt och infoga
def pad_and_append (at):
medan len (resultat) <= vid:
resultat.append ([])
resultat [vid] .append (data [data_idx])
# itera genom indata
medan data_idx  a:
om x  = l [0]) & (L  = i) & (L